{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of SRGAN\n",
    "Reference: https://arxiv.org/abs/1609.04802"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction\n",
    "In this task, we can use SRGAN to get high-resolution image from low-resolution image.    \n",
    "The dataset is a subset of CelebA.    \n",
    "1, we need to finetune the net G and D.    \n",
    "2, we can test how the net G generate Super-resolution image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.dataset import Dataset\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torchvision.utils import save_image\n",
    "import math\n",
    "import torch.nn.functional as F\n",
    "from torchvision.transforms import Compose, RandomCrop, ToTensor, ToPILImage, CenterCrop, Resize\n",
    "from tqdm import tqdm\n",
    "import datetime\n",
    "from PIL import Image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime\n",
    "import os, sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imshow, imsave\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "MODEL_NAME = 'SRGAN'\n",
    "DEVICE = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMAGE_DIM = (32, 32, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self, scale_factor):\n",
    "        upsample_block_num = int(math.log(scale_factor, 2))\n",
    "\n",
    "        super(Generator, self).__init__()\n",
    "        self.block1 = nn.Sequential(\n",
    "            nn.Conv2d(3, 64, kernel_size=9, padding=4),\n",
    "            nn.PReLU()\n",
    "        )\n",
    "        self.block2 = ResidualBlock(64)\n",
    "        self.block3 = ResidualBlock(64)\n",
    "        self.block4 = ResidualBlock(64)\n",
    "        self.block5 = ResidualBlock(64)\n",
    "        self.block6 = ResidualBlock(64)\n",
    "        self.block7 = nn.Sequential(\n",
    "            nn.Conv2d(64, 64, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(64)\n",
    "        )\n",
    "        block8 = [UpsampleBLock(64, 2) for _ in range(upsample_block_num)]\n",
    "        block8.append(nn.Conv2d(64, 3, kernel_size=9, padding=4))\n",
    "        self.block8 = nn.Sequential(*block8)\n",
    "\n",
    "    def forward(self, x):\n",
    "        block1 = self.block1(x)\n",
    "        block2 = self.block2(block1)\n",
    "        block3 = self.block3(block2)\n",
    "        block4 = self.block4(block3)\n",
    "        block5 = self.block5(block4)\n",
    "        block6 = self.block6(block5)\n",
    "        block7 = self.block7(block6)\n",
    "        block8 = self.block8(block1 + block7)\n",
    "\n",
    "        return (torch.tanh(block8) + 1) / 2\n",
    "\n",
    "\n",
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Conv2d(3, 64, kernel_size=3, padding=1),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(128, 256, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(256, 512, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(512),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(512),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.AdaptiveAvgPool2d(1),\n",
    "            nn.Conv2d(512, 1024, kernel_size=1),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Conv2d(1024, 1, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        return torch.sigmoid(self.net(x).view(batch_size))\n",
    "\n",
    "\n",
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(self, channels):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(channels)\n",
    "        self.prelu = nn.PReLU()\n",
    "        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(channels)\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = self.conv1(x)\n",
    "        residual = self.bn1(residual)\n",
    "        residual = self.prelu(residual)\n",
    "        residual = self.conv2(residual)\n",
    "        residual = self.bn2(residual)\n",
    "\n",
    "        return x + residual\n",
    "\n",
    "\n",
    "class UpsampleBLock(nn.Module):\n",
    "    def __init__(self, in_channels, up_scale):\n",
    "        super(UpsampleBLock, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, in_channels * up_scale ** 2, kernel_size=3, padding=1)\n",
    "        self.pixel_shuffle = nn.PixelShuffle(up_scale)\n",
    "        self.prelu = nn.PReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.pixel_shuffle(x)\n",
    "        x = self.prelu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_image_file(filename):\n",
    "    return any(filename.endswith(extension) for extension in ['.png', '.jpg', '.jpeg', '.PNG', '.JPG', '.JPEG'])\n",
    "\n",
    "def train_hr_transform():\n",
    "    return Compose([\n",
    "        Resize((128,128), interpolation=Image.BICUBIC),\n",
    "        ToTensor(),\n",
    "    ])\n",
    "\n",
    "def im_filter(directory, x):\n",
    "    if is_image_file(x):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def train_lr_transform():\n",
    "    return Compose([\n",
    "        ToPILImage(),\n",
    "        Resize((32,32), interpolation=Image.BICUBIC),\n",
    "        ToTensor(),\n",
    "    ])\n",
    "class TrainDatasetFromFolder(Dataset):\n",
    "    def __init__(self, dataset_dir, upscale_factor):\n",
    "        super(TrainDatasetFromFolder, self).__init__()\n",
    "        self.image_filenames = []\n",
    "\n",
    "        imgs = os.listdir(dataset_dir)\n",
    "        for x in tqdm(imgs):\n",
    "            if im_filter(imgs, x):\n",
    "                self.image_filenames.append(os.path.join(dataset_dir, x))\n",
    "        self.hr_transform = train_hr_transform()\n",
    "        self.lr_transform = train_lr_transform()\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        hr_image = self.hr_transform(Image.open(self.image_filenames[index]).convert(\"RGB\"))\n",
    "        lr_image = self.lr_transform(hr_image)\n",
    "        return lr_image, hr_image\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.image_filenames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CelebA-ch subset download: [link](https://drive.google.com/file/d/1RD55pZnakqEZn3FMPaoB2c1ShaouJJ_1/view?usp=sharing)    \n",
    "unzip it and put into current dir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "n_noise = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 402/402 [00:00<00:00, 227514.53it/s]\n"
     ]
    }
   ],
   "source": [
    "dataset = TrainDatasetFromFolder('./celeba/subset', 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=1, pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## build network G and D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "D = Discriminator().to(DEVICE)\n",
    "G = Generator(4).to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load pretrained G and D\n",
    "Train a full network needs GPU and many times. So we can finetune the network on the provided pretrained model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "download pretrained network: [link](https://drive.google.com/file/d/1nJ1x8Q5etIeQh0ZPdfLXb2c2Zx_nuQpK/view?usp=sharing)    \n",
    "put into current dir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pretrained_path = './srgan_pretrained.pth.tar'\n",
    "state = torch.load(pretrained_path,map_location=lambda storage, loc: storage)\n",
    "G.load_state_dict(state['G'])\n",
    "D.load_state_dict(state['D'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_opt = torch.optim.Adam(D.parameters())\n",
    "G_opt = torch.optim.Adam(G.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_epoch = 1\n",
    "log_term = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steps_per_epoch = len(data_loader.dataset) // batch_size\n",
    "steps_per_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('samples'):\n",
    "    os.makedirs('samples')\n",
    "    \n",
    "if not os.path.exists('ckpt'):\n",
    "    os.makedirs('ckpt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_checkpoint(state, file_name='checkpoint.pth.tar'):\n",
    "    torch.save(state, file_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/1, Step: 0/12, D Loss: 0.0021, G Loss: 1.0000, Time:01:34:09\n",
      "Epoch: 1/1, Step: 1/12, D Loss: 0.0109, G Loss: 1.0000, Time:01:34:38\n",
      "Epoch: 1/1, Step: 2/12, D Loss: 0.0042, G Loss: 1.0000, Time:01:35:06\n",
      "Epoch: 1/1, Step: 3/12, D Loss: 0.0041, G Loss: 1.0000, Time:01:35:35\n",
      "Epoch: 1/1, Step: 4/12, D Loss: 0.0062, G Loss: 1.0000, Time:01:36:03\n",
      "Epoch: 1/1, Step: 5/12, D Loss: 0.0040, G Loss: 1.0000, Time:01:36:31\n",
      "Epoch: 1/1, Step: 6/12, D Loss: 0.0041, G Loss: 1.0000, Time:01:36:59\n",
      "Epoch: 1/1, Step: 7/12, D Loss: 0.0031, G Loss: 1.0000, Time:01:37:27\n",
      "Epoch: 1/1, Step: 8/12, D Loss: 0.0029, G Loss: 1.0000, Time:01:37:55\n",
      "Epoch: 1/1, Step: 9/12, D Loss: 0.0029, G Loss: 1.0000, Time:01:38:23\n",
      "Epoch: 1/1, Step: 10/12, D Loss: 0.0037, G Loss: 1.0000, Time:01:38:51\n",
      "Epoch: 1/1, Step: 11/12, D Loss: 0.0031, G Loss: 1.0000, Time:01:39:19\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, max_epoch + 1):\n",
    "    step = 0\n",
    "\n",
    "    G.train()\n",
    "    D.train()\n",
    "    for data, target in data_loader:\n",
    "        g_update_first = True\n",
    "        batch_size = data.size(0)\n",
    "\n",
    "        ############################\n",
    "        # (1) Update D network: maximize D(x)-1-D(G(z))\n",
    "        ###########################\n",
    "        real_img = target\n",
    "        if torch.cuda.is_available():\n",
    "            real_img = real_img.cuda()\n",
    "        z = data\n",
    "        fake_img = G(z)\n",
    "\n",
    "        D.zero_grad()\n",
    "        real_out = D(real_img).mean()\n",
    "        fake_out = D(fake_img).mean()\n",
    "        d_loss = 1 - real_out + fake_out\n",
    "        d_loss.backward(retain_graph=True)\n",
    "        D_opt.step()\n",
    "\n",
    "        ############################\n",
    "        # (2) Update G network: minimize 1-D(G(z)) + Image Loss\n",
    "        ###########################\n",
    "        G.zero_grad()\n",
    "        g_loss = criterion(fake_img, real_img)\n",
    "        g_loss.backward()\n",
    "\n",
    "        fake_img = G(z)\n",
    "        fake_out = D(fake_img).mean()\n",
    "        G_opt.step()\n",
    "        \n",
    "        # loss for current batch before optimization \n",
    "        D_loss = g_loss.item()\n",
    "        G_loss = d_loss.item()\n",
    "\n",
    "        if step % log_term == 0:\n",
    "            dt = datetime.datetime.now().strftime('%H:%M:%S')\n",
    "            print('Epoch: {}/{}, Step: {}/{}, D Loss: {:.4f}, G Loss: {:.4f}, Time:{}'.format(epoch, max_epoch, step, steps_per_epoch, D_loss, G_loss, dt))\n",
    "        \n",
    "        step += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_checkpoint({'global_step': step,\n",
    "     'D':D.state_dict(),\n",
    "     'G':G.state_dict(),\n",
    "     'd_optim': D_opt.state_dict(),\n",
    "     'g_optim' : G_opt.state_dict()},\n",
    "    'ckpt/began{:06d}.pth.tar'.format(step))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Load the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G_path = sorted(glob.glob(os.path.join('ckpt', '*.pth.tar')))[-1]\n",
    "state = torch.load(G_path,map_location=lambda storage, loc: storage)\n",
    "G.load_state_dict(state['G'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.eval()\n",
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Input lr_img to net G, output sr_img."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### show lr_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x126580d10>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAa6klEQVR4nO2da4xdV3XH/+ucc1/z9njG9sQxcRISIKUlCUOUCpryEDRFVAGpisgHlA8RRhWRikQ/RKlUUqkfoCogPlGZEhEqSggvEVVRSxqBUkSV4NDESZzacV7E9tgTe8ae932d1Q/3up1Ee60Ze+bemfH+/yTLM3vNPmfdfe865979v2stUVUQQi59ko12gBDSHRjshEQCg52QSGCwExIJDHZCIoHBTkgkZGuZLCK3AvgGgBTAP6nql72/T9JUsywN2lwB0DDKxUxqzbwoEyRsFG9SYl9PxTgeACSei948Y2Iqth/WnJYfzv3A8cP20X5eOiED1+v14PjM7Ny6n2uzoKrBxZeLXWARSQEcAfBRAMcA/AbAHap6yJpTLBV1dNeuoK3pRG6e58HxQt154RhzAECcAHRfwIVicDzNSuactByeAwBZsWDaymn4oggA5YJ9je6thI/ZX6mYc3rKZdNWKdqPLXH8SLOwzXu9NZrhwFxpnmc7dfJUcPyxX/6n44f92tkKWMG+lrfxNwE4qqovq2oNwIMAblvD8QghHWQtwb4bwOvLfj/WHiOEbELW9Jl9NYjIPgD7ACB13poSQjrLWu7sxwHsWfb75e2xN6Gq+1V1XFXHk5Sb/4RsFGuJvt8AuEZErhSRIoBPA3h4fdwihKw3F/02XlUbInI3gH9HS3q7X1Wf9ycBibFz6okCli13JCN1dtVdec05prWLL6knvTlueAqEI3lpYj9tuYR343NHgVBvHb318NbYOp7zRFuqCwA0m03nmPY865iupIitvRtvsabP7Kr6CIBH1skXQkgH4YdoQiKBwU5IJDDYCYkEBjshkcBgJyQSOv4Nurdi5RikYssdFUPaKma29FPwklOcb/Ll4RyCls2QodSR0JqwJSPATpJpOH4sOYkaaSNsKzZsPzLHpqja52o2TJuVCajOuaoNOxGm4UhveW7bGkth/zPnNVAz1rB9Nse2ueGdnZBIYLATEgkMdkIigcFOSCQw2AmJhK7uxpezBNcNh0sg9Rfs0kioh3d989zeDW46yRE1Z/e22rR31muGH965cifBp1C0d7pR6TFNdbHXqloLn7DpZP8sOeW9Sk4JgsSrhWecL3HWo+k9n85z5tl6i+GXeF+PvYYL1Zpp81J/NnsjNd7ZCYkEBjshkcBgJyQSGOyERAKDnZBIYLATEgldld5KSYq9/QNB28zCkjnvzNxCcHzOkMIAoO4kp9TdriSmCQ1DYvPkmIIjyFTr9skKznqUS3aST1YMa2VZr90RJinYtmpqd61ZcLQmqz5dye3K5STWOPKmV8AwKYbvZ16HnMnpc/a5tjC8sxMSCQx2QiKBwU5IJDDYCYkEBjshkcBgJyQS1iS9icirAGYBNAE0VHXc+/tao4ETZ6aCtnOLttS0ZGSiNZ1LlZeRBafNkCR2mlcBYVvuyGtLjpaXO9lmqnY9trRu26yyfOnsrDlnpGhLeaODvaatWrFtk8ZjO+vU1sucVlNFtddRnPp0vUM7guODfX3mHI/NntnmsR46+4dU9fQ6HIcQ0kH4Np6QSFhrsCuAn4vIUyKybz0cIoR0hrW+jf+Aqh4XkR0AHhWR/1HVx5f/QfsisA8AyplT9oQQ0lHWdGdX1ePt/ycB/BTATYG/2a+q46o6XnQK8xNCOstFB7uI9IpI//mfAXwMwHPr5RghZH1Zy9v4nQB+2s5uygD8i6r+mzehqTnOVReDtpqjlDXSsOCRODJO05FjvCy11GnXlBrSUMM5YsORANPEvtY2nUwuGO2wWoTnefLgVC38nABAfcqW+fqKM6Zt19D24Ph0Zre8mraT3iDivFS95zo1st7KToHTS5SLDnZVfRnAe9bRF0JIB6H0RkgkMNgJiQQGOyGRwGAnJBIY7IREQlcLTuYKLBoZbF42UWJIXuoVGnRs6opvdkZcQY2st9zLlLMRT3pz/IBTfLFkpL2lRsYeAIjYftQdmW/W6Yu3+MZkcHz7YLjgKAAk5UHTNtGwdbnUKTx6YupscDwv2xKgz9bt9sY7OyGRwGAnJBIY7IREAoOdkEhgsBMSCV3djQeAhlH/LXN2OctitDTKnJ3zgr0P7u0+L9bsxA81VIGqtwvrJOt4ZfJSb56zVtaee8GrJeBtMIvTosqZWDISUGqzdmulHY4CUct6TNuk0eIJAI7PzAXHF6fCtRBXZnPvuHvwzk5IJDDYCYkEBjshkcBgJyQSGOyERAKDnZBI6Lr0Zl1dyk5SyIAh4+wc2WbO8aS3+aWaaZuaDUs1AFAzZJfZeft43tVUHHkt9XQ556DWvIrYslbitMMqZvZLJFH7cQ8Y61/M7NpvKezj7XGkt8W67eM5Q56dq9oS69ZNdfHhnZ2QSGCwExIJDHZCIoHBTkgkMNgJiQQGOyGRsKL0JiL3A/gEgElVfXd7bBjADwDsBfAqgNtVdXrFYwEoGZeXvoJ93dm5ayQ4Pjg0ZJ+sYctJOeZNW8/igmkrGMdc9FpXOZLXxWo8VhsqABjMwpJXObX9SAu2bbTPlrxKFbtmXKEQzrIrFkvmnLmq7Ycs2VLZtqZtmzUOmRpy7qXMah7xdwDc+paxewA8pqrXAHis/TshZBOzYrC3+62/Nfn3NgAPtH9+AMAn19kvQsg6c7HvZXaq6kT755NodXQlhGxi1vx1WVVVETE/YYrIPgD7AKAY4eckQjYLFxt9p0RkDADa/4c7AgBQ1f2qOq6q45nz/XdCSGe52Oh7GMCd7Z/vBPCz9XGHENIpViO9fR/ABwGMiMgxAF8C8GUAD4nIXQBeA3D7ak4mUBSM1kW7R8LyGgDM1JaC40eeP2TO2VaxJaOhnj7TVnEKM24zWgZlua2TeW2cEqfwpUelr9e07R7bFRyXqp1RtrgUXl8AqAz0m7ZG035scxouVClOy6iFmt3GaWlu1rQNpPbLOKuF11ic52wrZ7Z5rBjsqnqHYfrIOvtCCOkg/BBNSCQw2AmJBAY7IZHAYCckEhjshERCVwtOpiLoLYblKy3ZhQiPHvldcLxWs/uQ9RVseSo3O6IBg4N2Jt1lw2E5b9u8LRmJ8XgBoNm05xVLFdO24PSjO3EuXDCzaH/JEZWynYl27Kzdm+3slJ3oOG9kqUluP+ayUyR0W8kpfJnb96xGtRocbzqZcpcqvLMTEgkMdkIigcFOSCQw2AmJBAY7IZHAYCckErorvSUJBo2Cg0dPTATHAWBqMSzXDDqZbUtORtbU9FnTdu2eK03b1XtHg+OHjhwz55w4/YZpq5RtufHMlC15HT9t+39mLlxMM03s9ehx/GjWbckuMzIYAaBhZJUluS2XlhL7XIOZXWTz8LydtTdn9PVTp7/dpQrv7IREAoOdkEhgsBMSCQx2QiKBwU5IJHR1N14EyIy8kFNvhBM4AEAlnLiSOzvFi9VF0/Z7e3aYtvdee5lpG94e3rU+fMhuGXXquFl4F8PD20zbuTl7PaamZ0xbbuxaZ06ySNXYwQeAnsR+iewesBNX5iScyJM795f+olP9zWkbdfyMrVzUjLp2Xm1AOO214NSu2+zwzk5IJDDYCYkEBjshkcBgJyQSGOyERAKDnZBIWE37p/sBfALApKq+uz12H4DPAjif5XGvqj6y8rGAYjEsa+SOFGJ19xnsseu7vWv3dtP2R+NXm7axUbt2neZh38VpW9TXY9eS2/22t5m2xuuvm7ZRpz5dTxaWqPb02skul4/Y1/xr9to+vjFrS3aPPPlycHw6sSW00/N2gs+Ik0Bzzll/MZqJiqO8OcLblm4NtZo7+3cA3BoY/7qqXt/+t2KgE0I2lhWDXVUfBzDVBV8IIR1kLZ/Z7xaRgyJyv4jYXwUjhGwKLjbYvwngagDXA5gA8FXrD0Vkn4gcEJEDSw37cxchpLNcVLCr6ilVbapqDuBbAG5y/na/qo6r6njZ6X1OCOksFxXsIjK27NdPAXhufdwhhHSK1Uhv3wfwQQAjInIMwJcAfFBErkdLiXgVwOdWc7I0SbDNqHd21ZBdT266GtZJLhvuN+dcNTpo2oZ6bPknU3tJ8iT8zuSWP36fOeeWzJbyTs/Z73QWMns9ZidPmDbJw22Nhkb7zDk3Xn+VaXvXtbbtxWO2PHhiMtwa6vAZOxvx6JRdS65RsZ+XNLUFsUYj/Nrp67VfH0uL4ZZRAFCvhWvabQVWDHZVvSMw/O0O+EII6SD8Bh0hkcBgJyQSGOyERAKDnZBIYLATEgldLTiZCFAqheWmP3nftea8udlwVlPZuVRdMWJLXv2Z/bATO4EKhZ6wbDi2y/62cF3sAxYrdqHKD5XsbLMbpu3Hls+FM8dGt9ky5ciOcFsrAFhwMsqu3L3HtJU/HF6rwcO/M+dMnz5j2koFu7hlw8hGBIDh4V3B8auvtDMff/3rX5q2rSy98c5OSCQw2AmJBAY7IZHAYCckEhjshEQCg52QSOiq9JbniqX5cGZTZaeduXTZnuHgeHXW7oc2WLEz28QpolFfsqUVTcLyT+rIdUnBflxDTsHMbWXblu+wbaiPhP2wZ6Bccl4GRp89AKga2YgAUOkLF8V899vHguMA8PpLtu3UrJ2J9o5rf9+0bRsO9+4rpPaKZIWuhkXX4J2dkEhgsBMSCQx2QiKBwU5IJDDYCYmELu/G55hfCO92N6r2LviOHeFWTifV3qGtJvZOcaEWrtMGAHnTrpGWNsI760Wjrh4AlMq2KlBMbVuhZCd35OI0KDJ2/6vzdqumxQV7rbKirVw0nRZKA73hGnqZM+eKMTuhqJbZSUPZ6BWmbXo+/LrKnT5OiaG6bHV4ZyckEhjshEQCg52QSGCwExIJDHZCIoHBTkgkrKb90x4A3wWwE612T/tV9RsiMgzgBwD2otUC6nZVDff8adPIganFsJRzfGLSnPeOd4RbEEnZlkjyxL6O1RNbd0nEluWS3EgKqdvJIrmTcIGmndBSTO06c6jZctjCQjg5aHHunDlHEls6hNr+l5zWVrNvnA4fTmyJtVqz2z+haWcbSc1OiLIktjRx1r54aTYgXc2dvQHgi6p6HYCbAXxeRK4DcA+Ax1T1GgCPtX8nhGxSVgx2VZ1Q1d+2f54F8AKA3QBuA/BA+88eAPDJTjlJCFk7F/SZXUT2ArgBwBMAdqrqRNt0Eq23+YSQTcqqg11E+gD8GMAXVHVmuU1VFa3P86F5+0TkgIgcqHrfrySEdJRVBbuIFNAK9O+p6k/aw6dEZKxtHwMQ3GFT1f2qOq6q4yVvs4oQ0lFWjD4REbT6sb+gql9bZnoYwJ3tn+8E8LP1d48Qsl6sJuvt/QA+A+BZEXm6PXYvgC8DeEhE7gLwGoDbVzpQI88xuRjOKqvM2tedI6+8HhwfGQvXpgOAppMYlhWd9k9OzTXV8MeQHLacVK/aMlkC24a6nX2XL9kZYPP1sAyVDYYzBwEgTW3prV63Ja/pqQnTtjgb9nHBqdf37NHjpq2/f8i0lcWTUo1x5zVQLNjZiFuZFYNdVX8FwAqdj6yvO4SQTsEP0YREAoOdkEhgsBMSCQx2QiKBwU5IJHS5z40gRVjamrFrR+L5Q78Ljt9QCRc1BIDB7XZGVs0pRpkVbdklScPLJaZYAcCRrpYcea1anzVtp2dtWzYwGhzvVXutMkcPy8/ZPtbm7GwzGJljTx0JP5cAcHrGPldvOdxOCgASZx1LxcHguDpFO5M03qw3QsglAIOdkEhgsBMSCQx2QiKBwU5IJDDYCYmErkpvhVSwcyCcYTXnSFQNhOWwiWNvmHN6B2ypppY5RRQdGU2y8HJlmS3VSGofr5nbWW91u+4lsp4B53x9wfHFul1gsad/xLSlw/ZLRF6zs9Refv1ocPy/Dr1kzsmc3nfVmq3NDjrSW39/uIBSPbOlyIG+ftO2leGdnZBIYLATEgkMdkIigcFOSCQw2AmJhK7uxguAzEhA2NVv7zCXCmE3Fxp27bGp0zOmrTxm7z43mvYxa43wFnnm1EBLwxW2ARi1t/9/oslQxW57JamxjZ871/UzU6apds5pG1W32zUdPBpOeDk9b9fr2zVo18JrqqNqLNm78duMFmG1SjhBBgB6epzWW1sY3tkJiQQGOyGRwGAnJBIY7IREAoOdkEhgsBMSCStKbyKyB8B30WrJrAD2q+o3ROQ+AJ8FcD4b5V5VfcQ7Vj3PMbEQrlt2edG+7vQZMsmMkxzxyglbTlqs2vLPVW/bYdpyDSdqJLkthZW8WmemBSgmdlJIIbMlKk3Cmp3CaSdVckTAHrvVlKqdyHNqKbzGidiPOnUkzIaXNFS1XwfJ3HRwPOuzW4cVnDqEW5nV6OwNAF9U1d+KSD+Ap0Tk0bbt66r6D51zjxCyXqym19sEgIn2z7Mi8gKA3Z12jBCyvlzQZ3YR2QvgBgBPtIfuFpGDInK/iGxbZ98IIevIqoNdRPoA/BjAF1R1BsA3AVwN4Hq07vxfNebtE5EDInKg5nwVlRDSWVYV7CJSQCvQv6eqPwEAVT2lqk1tNS3/FoCbQnNVdb+qjqvqeNGp2kII6SwrBruICIBvA3hBVb+2bHxs2Z99CsBz6+8eIWS9WM1u/PsBfAbAsyLydHvsXgB3iMj1aMlxrwL43EoHUgBqZF/NO/LJdg23a5qdsWWhV2bt1kSHX3zNtM1N2a2V3nVNeF8y77OzpCo9du23XqfNkJPkBdgqFEpWnbxyuDYdAIgjD5b67Fp+xaV5+5hJ+HlWr8afc+upO2mA84v2a6d+6mRwfHjE3mMeGrg0a9CtZjf+V0DwGXI1dULI5oLfoCMkEhjshEQCg52QSGCwExIJDHZCIqGrBSdTCHoNmafitFCqNcOFDWedtj9nZm1ZLnU0nqdeOGbarhgNfyM4y8PSIADMTdu2c2X7MfdU7PZE5bJtWyqEpb5S2ZbJMkcCrBnZawDw5BF7rU6ePB0c7zH8AwBRp8pmamcW1gyZDwByI8tScvtx9ZTsc21leGcnJBIY7IREAoOdkEhgsBMSCQx2QiKBwU5IJHRXeksEA73hYoljA3ZW1ky1ERw/O2f3GltSp1BGHj4eAKRNO6UszcLXxl3b7QKQ1UVb4qkv2ec6/FJYugKAnx9+xbQVimFpy8soK6W2/2fP2lmAJ87afeCs/nwDRVuK9ApOlov2SzV3uuY1Ee5912jamXJirGHb6tg2d3EW3tkJiQQGOyGRwGAnJBIY7IREAoOdkEhgsBMSCV2V3pI0Qf9guIBhntiyxcmzM8Hxhaot41SbtkTSyMNyDACMDtiyy+hIONtMCvY1swS7b1jdkQAPT06YtmeO25JXwbh+O+3ocNmA3d+jOm8X7vSy5YYqYTmvrPZj7inYz1lB7Ofak96KhfD6N5wCp/29dgHR1HnMzab92DYDvLMTEgkMdkIigcFOSCQw2AmJBAY7IZGw4m68iJQBPA6g1P77H6nql0TkSgAPAtgO4CkAn1FVO+sDQDPPMbVg1JNzOrxOzYXrp9Ua9pzc2XHfWbYf9p/dfJ1pGx0eDPtRtxNalnI7WWfW2RE+7diysq0YZMamdeooBpXUXsfRQbve3YK3o23UcetJbFnASuIBgHrdfj7FSU7pM9pvFTK7rdVc3V6PzEiGAgAnh2pTsJo7exXAh1X1PWi1Z75VRG4G8BUAX1fVtwOYBnBX59wkhKyVFYNdW5wXWwvtfwrgwwB+1B5/AMAnO+IhIWRdWG1/9rTdwXUSwKMAXgJwVvX/viFxDIDdFpMQsuGsKthVtamq1wO4HMBNAN652hOIyD4ROSAiB6oN+1tQhJDOckG78ap6FsAvAPwhgCEROb/TdTmA48ac/ao6rqrjJWdzgxDSWVaMPhEZFZGh9s8VAB8F8AJaQf/n7T+7E8DPOuUkIWTtrCYRZgzAAyKSonVxeEhV/1VEDgF4UET+DsB/A/j2SgeqN3OcngrXNCtndsKIdU0qO1Nu++h7Tds7h+16d8MDdj22PA37oVVbc5k32g8BwPw5W7o6t+ComOokjJQMqclJFmk4stbgkJ0UUknsl09vb3iN1ZFEC0V77esNe5460mezEU5OKZbt14A6raESp9XUZmfFYFfVgwBuCIy/jNbnd0LIFmDrXqYIIRcEg52QSGCwExIJDHZCIoHBTkgkiHptktb7ZCJvAHit/esIALvHUfegH2+GfryZrebHFao6GjJ0NdjfdGKRA6o6viEnpx/0I0I/+DaekEhgsBMSCRsZ7Ps38NzLoR9vhn68mUvGjw37zE4I6S58G09IJGxIsIvIrSJyWESOisg9G+FD249XReRZEXlaRA508bz3i8ikiDy3bGxYRB4VkRfb/9s9mTrrx30icry9Jk+LyMe74MceEfmFiBwSkedF5C/b411dE8ePrq6JiJRF5EkReabtx9+2x68UkSfacfMDEbErdIZQ1a7+A5CiVdbqKgBFAM8AuK7bfrR9eRXAyAac9xYANwJ4btnY3wO4p/3zPQC+skF+3Afgr7q8HmMAbmz/3A/gCIDrur0mjh9dXRMAAqCv/XMBwBMAbgbwEIBPt8f/EcBfXMhxN+LOfhOAo6r6srZKTz8I4LYN8GPDUNXHAUy9Zfg2tAp3Al0q4Gn40XVUdUJVf9v+eRat4ii70eU1cfzoKtpi3Yu8bkSw7wbw+rLfN7JYpQL4uYg8JSL7NsiH8+xU1fOtW08C2LmBvtwtIgfbb/M7/nFiOSKyF636CU9gA9fkLX4AXV6TThR5jX2D7gOqeiOAPwXweRG5ZaMdAlpXdsApLdNZvgngarR6BEwA+Gq3TiwifQB+DOALqvqmPt3dXJOAH11fE11DkVeLjQj24wD2LPvdLFbZaVT1ePv/SQA/xcZW3jklImMA0P5/ciOcUNVT7RdaDuBb6NKaiEgBrQD7nqr+pD3c9TUJ+bFRa9I+9wUXebXYiGD/DYBr2juLRQCfBvBwt50QkV4R6T//M4CPAXjOn9VRHkarcCewgQU8zwdXm0+hC2siIoJWDcMXVPVry0xdXRPLj26vSceKvHZrh/Etu40fR2un8yUAf71BPlyFlhLwDIDnu+kHgO+j9XawjtZnr7vQ6pn3GIAXAfwHgOEN8uOfATwL4CBawTbWBT8+gNZb9IMAnm7/+3i318Txo6trAuAP0CriehCtC8vfLHvNPgngKIAfAihdyHH5DTpCIiH2DTpCooHBTkgkMNgJiQQGOyGRwGAnJBIY7IREAoOdkEhgsBMSCf8LyPCYBNoI17YAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_img, hr_img = dataset[1]\n",
    "imshow(lr_img.data.permute(1,2,0).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### show sr_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1266c4b90>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "out = G(lr_img[None,:])\n",
    "out = out[0].data.permute(1,2,0).numpy()\n",
    "imshow(out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### show hr_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1271424d0>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow(hr_img.data.permute(1,2,0).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
